// i18n.js - 优化后的国际化模块

// 支持的语言列表
const SUPPORTED_LANGUAGES = {
  'zh': { name: '中文', nativeName: '中文', direction: 'ltr' },
  'en': { name: 'English', nativeName: 'English', direction: 'ltr' },
  'ja': { name: 'Japanese', nativeName: '日本語', direction: 'ltr' },
  'hi': { name: 'Hindi', nativeName: 'हिन्दी', direction: 'ltr' },
  'ar': { name: 'Arabic', nativeName: 'العربية', direction: 'rtl' },
  'fr': { name: 'French', nativeName: 'Français', direction: 'ltr' },
  'de': { name: 'German', nativeName: 'Deutsch', direction: 'ltr' },
  'es': { name: 'Spanish', nativeName: 'Español', direction: 'ltr' }
};

// 国家/地区代码到语言的映射
const COUNTRY_TO_LANGUAGE = {
  // 中文
  'CN': 'zh', 'HK': 'zh', 'TW': 'zh', 'MO': 'zh', 'SG': 'zh',
  // 英语
  'US': 'en', 'GB': 'en', 'AU': 'en', 'CA': 'en', 'NZ': 'en', 'IE': 'en',
  // 日语
  'JP': 'ja',
  // 印地语
  'IN': 'hi',
  // 阿拉伯语
  'SA': 'ar', 'AE': 'ar', 'EG': 'ar', 'IQ': 'ar', 'JO': 'ar', 'KW': 'ar', 'LB': 'ar', 'OM': 'ar', 'QA': 'ar', 'SY': 'ar',
  // 法语
  'FR': 'fr', 'BE': 'fr', 'CH': 'fr', 'LU': 'fr', 'MC': 'fr',
  // 德语
  'DE': 'de', 'AT': 'de', 'CH': 'de', 'LI': 'de', 'LU': 'de',
  // 西班牙语
  'ES': 'es', 'AR': 'es', 'BO': 'es', 'CL': 'es', 'CO': 'es', 'CR': 'es', 'DO': 'es', 'EC': 'es', 'GT': 'es', 'HN': 'es', 'MX': 'es', 'NI': 'es', 'PA': 'es', 'PE': 'es', 'PR': 'es', 'PY': 'es', 'SV': 'es', 'UY': 'es', 'VE': 'es'
};

// 缓存已加载的翻译
const translations = {};

// 当前语言
let currentLang = 'en';

// 应用配置
let appConfig = null;

// 初始化状态标志
let isInitialized = false;

// 获取重复次数
function getRepetitions() {
  // 如果appConfig已设置，则使用其中的repetitions值
  if (window.appConfig && typeof window.appConfig.repetitions === 'number') {
    return window.appConfig.repetitions;
  }
  // 否则返回默认值2
  return 2;
}

// 默认翻译（用于回退）
const DEFAULT_TRANSLATIONS = {
  'zh': {
    // 页面标题
    'documentTitle': '录音应用',
    // 提示文本模板
    'promptTemplate': '请以<span id="speed-indicator" class="highlight">{speed}</span>速度阅读下面的加粗单词',
    // 按钮
    'prevBtn': '上一词',
    'recordBtn': '录音',
    'nextBtn': '下一词',
    // 加载指示器
    'loading': '上传中...',
    'loadingLanguage': '加载语言中...',
    // 提示区域
    'hint1': '请按录音按钮开始录音，每个单词会重复<strong class="highlight">' + getRepetitions() + '</strong>次，如果录音结果和单词不符，将被拒绝',
    'hint2': '每次读完一个词再点击下一词（不要在读词时点击）',
    'hint3': '重新录上一词点击上一词',
    // 进度信息
    'speedProgress': '当前进度：',
    // 语言切换
    'switchLang': '切换语言',
    // 速度文本
    'normalSpeed': '正常',
    'fastSpeed': '快速',
    'slowSpeed': '缓慢',
    // 上传成功相关文本
    'uploadSuccess': '录音上传成功！',
    'uploadSuccessProlific': '录音上传成功！即将返回Prolific平台。',
    'congratsComplete': '恭喜完成任务',
    'returnToProlific': '即将返回Prolific平台',
    'uploadSuccessText': '录音上传成功',
    'completed': '已完成',
    'congratsAllComplete': '恭喜完成所有录音任务',
    'returnBtnProlific': '点击返回Prolific平台',
    'returnBtn': '返回',
    'noUrlMsg': '任务完成，但无法获取返回链接。',
    // 错误信息
    'uploadError': '上传失败，请重试',
    'recordingError': '录音失败，请检查麦克风权限',
    // 警告信息
    'completeAllWordsAlert': '您已经完成了所有单词，请点击完成或提交按钮',
    'next_word': '每次读完一个词再点击下一词（不要在读词时点击）',
    'prev_word': '重新录上一词点击上一词',
    // 录音状态
    'pause': '暂停',
    'resume': '继续',
    'complete': '完成',
    'submit': '提交录音',
    'play': '播放',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 录音状态相关
    'recordingSaved': '录音状态已保存',
    'recordingRestoreFailed': '恢复录音状态失败',
    'recordingProgressRestored': '已恢复之前的录音进度',
    'progressRestored': '进度已恢复',
    'restorePrompt': '检测到未完成的录音，是否恢复？',
    'restoreYes': '是，恢复',
    'restoreNo': '否，重新开始',
    // 添加新的消息翻译
    'audioDataRestored': '已恢复之前的录音数据',
    'continueRecording': '可以继续录音了',
    'recordingComplete': '录音已完成！'
  },
  'en': {
    // 页面标题
    'documentTitle': 'Voice Recording',
    // 提示文本模板
    'promptTemplate': 'Please read the bold word below at <span id="speed-indicator" class="highlight">{speed}</span> speed',
    // 按钮
    'prevBtn': 'Previous',
    'recordBtn': 'Record',
    'nextBtn': 'Next',
    // 加载指示器
    'loading': 'Uploading...',
    'loadingLanguage': 'Loading language...',
    // 提示区域
    'hint1': 'Please press the record button to start recording. Each word will be repeated <strong class="highlight">' + getRepetitions() + '</strong> times. If the recording result does not match the word, it will be rejected',
    'hint2': 'Click next AFTER reading each word (not while reading)',
    'hint3': 'Click previous to re-record the last word',
    // 进度信息
    'speedProgress': 'Current progress: ',
    // 语言切换
    'switchLang': 'Switch Language',
    // 速度文本
    'normalSpeed': 'normal',
    'fastSpeed': 'fast',
    'slowSpeed': 'slow',
    // 上传成功相关文本
    'uploadSuccess': 'Recording uploaded successfully!',
    'uploadSuccessProlific': 'Recording uploaded successfully! Returning to Prolific platform.',
    'congratsComplete': 'Congratulations on completing the task',
    'returnToProlific': 'Returning to Prolific platform',
    'uploadSuccessText': 'Recording uploaded successfully',
    'completed': 'Completed',
    'congratsAllComplete': 'Congratulations on completing all recording tasks',
    'returnBtnProlific': 'Click to return to Prolific platform',
    'returnBtn': 'Return',
    'noUrlMsg': 'Task completed, but unable to get the return link.',
    // 录音状态
    'pause': 'Pause',
    'resume': 'Continue',
    'complete': 'Complete',
    'submit': 'Submit Recording',
    // 错误信息
    'errorProcessingResponse': 'Error processing response, but will still try to redirect: {message}',
    // 警告信息
    'completeAllWordsAlert': 'You have completed all words, please click Complete or Submit button',
    'next_word': 'Click "Next Word" after reading each word (do not click while reading)',
    'prev_word': 'Click "Previous Word" to re-record the previous word',
    'play': 'Play',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 录音状态相关
    'recordingSaved': 'Recording state saved',
    'recordingRestoreFailed': 'Recording state restore failed',
    'recordingProgressRestored': 'Recording progress restored from previous',
    'progressRestored': 'Progress restored',
    'restorePrompt': 'Detected unfinished recording, restore?',
    'restoreYes': 'Yes, restore',
    'restoreNo': 'No, start over',
    // 添加新的消息翻译
    'audioDataRestored': 'Previous recording data has been restored',
    'continueRecording': 'You can continue recording now'
  },
  'ja': {
    // 页面标题
    'documentTitle': '音声録音',
    // 提示文本模板
    'promptTemplate': '下の太字の単語を<span id="speed-indicator" class="highlight">{speed}</span>速度で読んでください',
    // 按钮
    'prevBtn': '前へ',
    'recordBtn': '録音',
    'nextBtn': '次へ',
    // 加载指示器
    'loading': 'アップロード中...',
    'loadingLanguage': '言語読み込み中...',
    // 提示区域
    'hint1': '録音ボタンを押して録音を開始してください。各単語は<strong class="highlight">' + getRepetitions() + '</strong>回繰り返されます。録音結果が単語と一致しない場合は拒否されます',
    'hint2': '各単語を読み終わった後に「次へ」をクリックしてください（読んでいる最中にクリックしないでください）',
    'hint3': '前の単語を再録音するには「前へ」をクリックしてください',
    // 进度信息
    'speedProgress': '現在の進捗: ',
    // 语言切换
    'switchLang': '言語を切り替える',
    // 速度文本
    'normalSpeed': '通常',
    'fastSpeed': '速い',
    'slowSpeed': '遅い',
    // その他の翻訳...
    'uploadSuccess': '録音がアップロードされました！',
    'uploadSuccessProlific': '録音のアップロードが成功しました！Prolificプラットフォームに戻ります。',
    'completeAllWordsAlert': 'すべての単語を完了しました。完了または送信ボタンをクリックしてください',
    'next_word': '各単語を読み終えてから「次の単語」をクリックしてください（読んでいる間はクリックしないでください）',
    'prev_word': '前の単語を再録音するには「前の単語」をクリックしてください',
    'play': '再生',
    'pause': '一時停止',
    'resume': '続ける',
    'recordBtn': '録音',
    'submit': '録音を提出',
    'complete': '完了',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 录音状态相关
    'recordingSaved': '録音状態保存済み',
    'recordingRestoreFailed': '録音状態復元失敗',
    'recordingProgressRestored': '録音進捗復元済み',
    'progressRestored': '進捗復元済み',
    'restorePrompt': '未完了録音検出、復元？',
    'restoreYes': 'はい、復元',
    'restoreNo': 'いいえ、再開始',
    // 添加新的消息翻译
    'audioDataRestored': '以前の録音データが復元されました',
    'continueRecording': '録音を続けることができます'
  },
  'hi': {
    // 页面标题
    'documentTitle': 'आवाज़ रिकॉर्डिंग',
    // 提示文本模板
    'promptTemplate': 'कृपया नीचे मोटे शब्द को <span id="speed-indicator" class="highlight">{speed}</span> गति से पढ़ें',
    // 按钮
    'prevBtn': 'पिछला',
    'recordBtn': 'रिकॉर्ड',
    'nextBtn': 'अगला',
    // 加载指示器
    'loading': 'अपलोड हो रहा है...',
    'loadingLanguage': 'भाषा लोड हो रही है...',
    // 提示区域
    'hint1': 'रिकॉर्डिंग शुरू करने के लिए रिकॉर्ड बटन दबाएं। प्रत्येक शब्द <strong class="highlight">' + getRepetitions() + '</strong> बार दोहराया जाएगा। यदि रिकॉर्डिंग परिणाम शब्द से मेल नहीं खाता है, तो इसे अस्वीकार कर दिया जाएगा',
    'hint2': 'प्रत्येक शब्द को पढ़ने के बाद ही अगला बटन पर क्लिक करें (पढ़ते समय क्लिक न करें)',
    'hint3': 'पिछले शब्द को फिर से रिकॉर्ड करने के लिए पिछला बटन पर क्लिक करें',
    // 进度信息
    'speedProgress': 'वर्तमान प्रगति: ',
    // 语言切换
    'switchLang': 'भाषा बदलें',
    // 速度文本
    'normalSpeed': 'सामान्य',
    'fastSpeed': 'तेज़',
    'slowSpeed': 'धीमा',
    // その他の翻訳...
    'uploadSuccess': 'रिकॉर्डिंग सफलतापूर्वक अपलोड की गई!',
    'completeAllWordsAlert': 'आपने सभी शब्द पूरे कर लिए हैं, कृपया पूर्ण या जमा बटन पर क्लिक करें',
    'next_word': 'प्रत्येक शब्द पढ़ने के बाद "अगला शब्द" पर क्लिक करें (पढ़ते समय क्लिक न करें)',
    'prev_word': 'पिछले शब्द को फिर से रिकॉर्ड करने के लिए "पिछला शब्द" पर क्लिक करें',
    'play': 'चलाएं',
    'pause': 'रोकें',
    'resume': 'जारी रखें',
    'recordBtn': 'रिकॉर्ड',
    'submit': 'रिकॉर्डिंग जमा करें',
    'complete': 'पूर्ण',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 添加新的消息翻译
    'audioDataRestored': 'Previous recording data has been restored'
  },
  'ar': {
    // 页面标题
    'documentTitle': 'تسجيل صوتي',
    // 提示文本模板
    'promptTemplate': 'يرجى قراءة الكلمة الغامقة أدناه بسرعة <span id="speed-indicator" class="highlight">{speed}</span>',
    // 按钮
    'prevBtn': 'السابق',
    'recordBtn': 'تسجيل',
    'nextBtn': 'التالي',
    // 加载指示器
    'loading': 'جاري التحميل...',
    'loadingLanguage': 'جاري تحميل اللغة...',
    // 提示区域
    'hint1': 'يرجى الضغط على زر التسجيل لبدء التسجيل. سيتم تكرار كل كلمة <strong class="highlight">' + getRepetitions() + '</strong> مرات. إذا لم تتطابق نتيجة التسجيل مع الكلمة، سيتم رفضها',
    'hint2': 'انقر فوق التالي بعد قراءة كل كلمة (وليس أثناء القراءة)',
    'hint3': 'انقر فوق السابق لإعادة تسجيل الكلمة الأخيرة',
    // 进度信息
    'speedProgress': 'التقدم الحالي: ',
    // 语言切换
    'switchLang': 'تغيير اللغة',
    // 速度文本
    'normalSpeed': 'عادي',
    'fastSpeed': 'سريع',
    'slowSpeed': 'بطيء',
    // その他の翻訳...
    'uploadSuccess': 'تم تحميل التسجيل بنجاح!',
    'completeAllWordsAlert': 'لقد أكملت جميع الكلمات، يرجى النقر فوق زر الإكمال أو التقديم',
    'next_word': 'انقر على "الكلمة التالية" بعد قراءة كل كلمة (لا تنقر أثناء القراءة)',
    'prev_word': 'انقر على "الكلمة السابقة" لإعادة تسجيل الكلمة السابقة',
    'play': 'تشغيل',
    'pause': 'توقف مؤقت',
    'resume': 'استمرار',
    'recordBtn': 'تسجيل',
    'submit': 'تقديم التسجيل',
    'complete': 'مكتمل',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 添加新的消息翻译
    'audioDataRestored': 'Previous recording data has been restored'
  },
  'fr': {
    // 页面标题
    'documentTitle': 'Enregistrement vocal',
    // 提示文本模板
    'promptTemplate': 'Veuillez lire le mot en gras ci-dessous à une vitesse <span id="speed-indicator" class="highlight">{speed}</span>',
    // 按钮
    'prevBtn': 'Précédent',
    'recordBtn': 'Enregistrer',
    'nextBtn': 'Suivant',
    // 加载指示器
    'loading': 'Téléchargement...',
    'loadingLanguage': 'Chargement de la langue...',
    // 提示区域
    'hint1': 'Veuillez appuyer sur le bouton d\'enregistrement pour commencer. Chaque mot sera répété <strong class="highlight">' + getRepetitions() + '</strong> fois. Si le résultat de l\'enregistrement ne correspond pas au mot, il sera rejeté',
    'hint2': 'Cliquez sur suivant APRÈS avoir lu chaque mot (pas pendant la lecture)',
    'hint3': 'Cliquez sur précédent pour réenregistrer le dernier mot',
    // 进度信息
    'speedProgress': 'Progression actuelle: ',
    // 语言切换
    'switchLang': 'Changer de langue',
    // 速度文本
    'normalSpeed': 'normale',
    'fastSpeed': 'rapide',
    'slowSpeed': 'lente',
    // その他の翻訳...
    'uploadSuccess': 'Enregistrement téléchargé avec succès!',
    'completeAllWordsAlert': 'Vous avez terminé tous les mots, veuillez cliquer sur le bouton Terminer ou Soumettre',
    'next_word': 'Cliquez sur "Mot Suivant" après avoir lu chaque mot (ne cliquez pas pendant la lecture)',
    'prev_word': 'Cliquez sur "Mot Précédent" pour réenregistrer le mot précédent',
    'play': 'Lecture',
    'pause': 'Pause',
    'resume': 'Continuer',
    'recordBtn': 'Enregistrer',
    'submit': 'Soumettre l\'enregistrement',
    'complete': 'Terminé',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 添加新的消息翻译
    'audioDataRestored': 'Previous recording data has been restored'
  },
  'de': {
    // 页面标题
    'documentTitle': 'Sprachaufnahme',
    // 提示文本模板
    'promptTemplate': 'Bitte lesen Sie das fettgedruckte Wort unten mit <span id="speed-indicator" class="highlight">{speed}</span> Geschwindigkeit',
    // 按钮
    'prevBtn': 'Zurück',
    'recordBtn': 'Aufnehmen',
    'nextBtn': 'Weiter',
    // 加载指示器
    'loading': 'Wird hochgeladen...',
    'loadingLanguage': 'Sprache wird geladen...',
    // 提示区域
    'hint1': 'Bitte drücken Sie die Aufnahmetaste, um die Aufnahme zu starten. Jedes Wort wird <strong class="highlight">' + getRepetitions() + '</strong> mal wiederholt. Wenn das Aufnahmeergebnis nicht mit dem Wort übereinstimmt, wird es abgelehnt',
    'hint2': 'Klicken Sie auf Weiter NACHDEM Sie jedes Wort gelesen haben (nicht während des Lesens)',
    'hint3': 'Klicken Sie auf Zurück, um das letzte Wort neu aufzunehmen',
    // 进度信息
    'speedProgress': 'Aktueller Fortschritt: ',
    // 语言切换
    'switchLang': 'Sprache wechseln',
    // 速度文本
    'normalSpeed': 'normal',
    'fastSpeed': 'schnell',
    'slowSpeed': 'langsam',
    // 上传成功相关文本
    'uploadSuccess': 'Aufnahme erfolgreich hochgeladen!',
    'uploadSuccessProlific': 'Aufnahme erfolgreich hochgeladen! Rückkehr zur Prolific-Plattform.',
    'congratsComplete': 'Herzlichen Glückwunsch zum Abschluss der Aufgabe',
    'returnToProlific': 'Rückkehr zur Prolific-Plattform',
    'uploadSuccessText': 'Aufnahme erfolgreich hochgeladen',
    'completed': 'Abgeschlossen',
    'congratsAllComplete': 'Herzlichen Glückwunsch zum Abschluss aller Aufnahmeaufgaben',
    'returnBtnProlific': 'Klicken Sie, um zur Prolific-Plattform zurückzukehren',
    'returnBtn': 'Zurück',
    'noUrlMsg': 'Aufgabe abgeschlossen, aber der Rückgabelink konnte nicht abgerufen werden.',
    // 错误信息
    'microphoneAccessError': 'Zugriff auf das Mikrofon nicht möglich. Bitte stellen Sie sicher, dass Sie die Berechtigung erteilt haben.',
    'errorProcessingResponse': 'Fehler bei der Verarbeitung der Antwort, aber es wird trotzdem versucht weiterzuleiten: {message}',
    // 录音状态
    'recordingTime': 'Aufnahmezeit',
    'totalTime': 'Gesamtzeit',
    'pause': 'Pause',
    'resume': 'Fortsetzen',
    'play': 'Abspielen',
    'submit': 'Aufnahme abschließen',
    'complete': 'Abgeschlossen',
    // 警告信息
    'completeAllWordsAlert': 'Sie haben alle Wörter abgeschlossen, bitte klicken Sie auf die Schaltfläche Abschließen oder Absenden',
    'next_word': 'Klicken Sie nach dem Lesen jedes Wortes auf "Nächstes Wort" (klicken Sie nicht während des Lesens)',
    'prev_word': 'Klicken Sie auf "Vorheriges Wort", um das vorherige Wort neu aufzunehmen',
    // 加载和状态
    'uploading': 'Wird hochgeladen...',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 添加新的消息翻译
    'audioDataRestored': 'Previous recording data has been restored'
  },
  'es': {
    // 页面标题
    'documentTitle': 'Grabación de voz',
    // 提示文本模板
    'promptTemplate': 'Por favor, lee la palabra en negrita a continuación a una velocidad <span id="speed-indicator" class="highlight">{speed}</span>',
    // 按钮
    'prevBtn': 'Anterior',
    'recordBtn': 'Grabar',
    'nextBtn': 'Siguiente',
    // 加载指示器
    'loading': 'Subiendo...',
    'loadingLanguage': 'Cargando idioma...',
    // 提示区域
    'hint1': 'Por favor, presiona el botón de grabación para comenzar. Cada palabra se repetirá <strong class="highlight">' + getRepetitions() + '</strong> veces. Si el resultado de la grabación no coincide con la palabra, será rechazado',
    'hint2': 'Haz clic en siguiente DESPUÉS de leer cada palabra (no mientras estás leyendo)',
    'hint3': 'Haz clic en anterior para volver a grabar la última palabra',
    // 进度信息
    'speedProgress': 'Progreso actual: ',
    // 语言切换
    'switchLang': 'Cambiar idioma',
    // 速度文本
    'normalSpeed': 'normal',
    'fastSpeed': 'rápida',
    'slowSpeed': 'lenta',
    // その他の翻訳...
    'uploadSuccess': '¡Grabación subida con éxito!',
    'completeAllWordsAlert': 'Has completado todas las palabras, por favor haz clic en el botón Completar o Enviar',
    'next_word': 'Haga clic en "Siguiente palabra" después de leer cada palabra (no haga clic mientras lee)',
    'prev_word': 'Haga clic en "Palabra anterior" para volver a grabar la palabra anterior',
    'play': 'Reproducir',
    'pause': 'Pausar',
    'resume': 'Continuar',
    'recordBtn': 'Grabar',
    'submit': 'Enviar grabación',
    'complete': 'Completado',
    // 添加之前删除的翻译键，但不显示内容
    'recordingHint': ' ',
    'completeHint': ' ',
    // 添加新的消息翻译
    'audioDataRestored': 'Previous recording data has been restored'
  }
};

// 初始化默认翻译
translations['zh'] = DEFAULT_TRANSLATIONS['zh'];
translations['en'] = DEFAULT_TRANSLATIONS['en'];
translations['de'] = DEFAULT_TRANSLATIONS['de'];

/**
 * 从URL参数中获取语言设置
 * @returns {string|null} 语言代码或null
 */
function getLanguageFromUrl() {
    try {
        const urlParams = new URLSearchParams(window.location.search);
        const langParam = urlParams.get('lang');
        
        if (langParam && SUPPORTED_LANGUAGES[langParam]) {
            return langParam;
        }
    } catch (error) {
        console.error('从URL获取语言时出错:', error);
    }
    return null;
}

/**
 * 从HTML元素的lang属性中获取语言设置
 * @returns {string|null} 语言代码或null
 */
function getLanguageFromHtml() {
    try {
        const htmlLang = document.documentElement.lang;
        if (htmlLang) {
            // 尝试完整匹配
            if (SUPPORTED_LANGUAGES[htmlLang]) {
                return htmlLang;
            }
            
            // 尝试基本语言代码匹配 (如 "zh-CN" -> "zh")
            const baseLang = htmlLang.split('-')[0];
            if (SUPPORTED_LANGUAGES[baseLang]) {
                return baseLang;
            }
        }
    } catch (error) {
        console.error('从HTML获取语言时出错:', error);
    }
    return null;
}

/**
 * 从浏览器语言设置中获取支持的语言
 * @returns {string|null} 语言代码或null
 */
function getBrowserLanguage() {
    try {
        const browserLangs = navigator.languages || [navigator.language || navigator.userLanguage];
        
        for (const lang of browserLangs) {
            // 完整匹配 (如 "zh-CN")
            if (SUPPORTED_LANGUAGES[lang]) {
                return lang;
            }
            
            // 基本语言代码匹配 (如 "zh-CN" -> "zh")
            const baseLang = lang.split('-')[0];
            if (SUPPORTED_LANGUAGES[baseLang]) {
                return baseLang;
            }
        }
    } catch (error) {
        console.error('从浏览器获取语言时出错:', error);
    }
    return null;
}

/**
 * 基于用户地理位置检测语言
 * 尝试多个免费API服务，如果一个失败则尝试下一个
 */
async function detectLocationBasedLanguage() {
    // 为避免重复调用API，首先检查本地存储
    const cachedLocation = localStorage.getItem('user_location_info');
    const cacheTime = localStorage.getItem('user_location_timestamp');
    
    // 检查缓存是否有效（24小时内）
    if (cachedLocation && cacheTime) {
        const now = Date.now();
        const cacheAge = now - parseInt(cacheTime);
        
        // 如果缓存不超过24小时，使用缓存的数据
        if (cacheAge < 24 * 60 * 60 * 1000) {
            try {
                const locationData = JSON.parse(cachedLocation);
                console.log('使用缓存的地理位置数据:', locationData);
                
                // 从缓存返回国家代码
                if (locationData.country_code) {
                    return locationData.country_code.toLowerCase();
                }
                if (locationData.country) {
                    return locationData.country.toLowerCase();
                }
            } catch (e) {
                console.error('解析缓存的地理位置数据失败:', e);
                // 缓存数据无效，继续尝试API
            }
        }
    }
    
    // 尝试多个免费API服务
    const geoServices = [
        {
            url: 'https://ipinfo.io/json',
            processResponse: (data) => data.country?.toLowerCase()
        },
        {
            url: 'https://ip-api.com/json',
            processResponse: (data) => data.countryCode?.toLowerCase()
        },
        // ipapi.co 经常受到限制，放在最后尝试
        {
            url: 'https://ipapi.co/json/',
            processResponse: (data) => data.country_code?.toLowerCase()
        }
    ];
    
    for (const service of geoServices) {
        try {
            console.log('尝试地理定位服务:', service.url);
            
            const response = await fetch(service.url, {
                method: 'GET',
                // 添加timeout和mode配置
                signal: AbortSignal.timeout(5000), // 5秒超时
                headers: {
                    'Accept': 'application/json'
                }
            });
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            console.log('地理定位成功:', data);
            
            // 缓存结果到本地存储
            localStorage.setItem('user_location_info', JSON.stringify(data));
            localStorage.setItem('user_location_timestamp', Date.now().toString());
            
            // 处理和返回国家代码
            const countryCode = service.processResponse(data);
            if (countryCode) {
                return countryCode;
            }
        } catch (error) {
            console.error(`地理定位服务 ${service.url} 失败:`, error);
            // 继续尝试下一个服务
        }
    }
    
    console.warn('所有地理定位服务都失败，使用浏览器语言');
    return null; // 无法确定地理位置，使用浏览器语言
}

/**
 * 检测用户语言，按优先级：
 * 1. URL参数
 * 2. HTML属性
 * 3. 地理位置
 * 4. 浏览器语言
 * 5. 默认语言（英语）
 */
async function detectUserLanguage() {
    try {
        // 1. 首先检查URL参数
        const urlLang = getLanguageFromUrl();
        if (urlLang) {
            console.log('从URL检测到语言:', urlLang);
            return urlLang;
        }
        
        // 2. 检查HTML元素上的语言属性
        const htmlLang = getLanguageFromHtml();
        if (htmlLang) {
            console.log('从HTML属性检测到语言:', htmlLang);
            return htmlLang;
        }
        
        // 3. 基于地理位置检测（如果可用）
        try {
            const countryCode = await detectLocationBasedLanguage();
            if (countryCode) {
                // 将国家代码转换为语言代码
                const geoLang = COUNTRY_TO_LANGUAGE[countryCode];
                if (geoLang) {
                    console.log(`根据地理位置(${countryCode})检测到语言:`, geoLang);
                    return geoLang;
                }
            }
        } catch (error) {
            console.warn('地理位置检测失败，使用浏览器语言:', error);
            // 地理位置检测失败，继续尝试浏览器语言
        }
        
        // 4. 使用浏览器语言设置
        const browserLang = getBrowserLanguage();
        if (browserLang) {
            console.log('从浏览器设置检测到语言:', browserLang);
            return browserLang;
        }
    } catch (error) {
        console.error('语言检测过程中发生错误:', error);
    }
    
    // 5. 默认使用英语
    console.log('无法检测语言，使用默认语言: en');
    return 'en';
}

// 加载语言文件
async function loadLanguage(langCode) {
  // 如果参数无效，使用默认英语
  if (!langCode || typeof langCode !== 'string') {
    console.warn('无效的语言代码，使用默认语言(en)');
    langCode = 'en';
  }
  
  // 检查语言是否已经加载
  if (translations[langCode]) {
    console.log(`语言 ${langCode} 已加载，直接使用`);
    return translations[langCode];
  }
  
  // 如果有默认翻译，使用默认翻译
  if (DEFAULT_TRANSLATIONS[langCode]) {
    console.log(`使用内置的语言包: ${langCode}`);
    translations[langCode] = DEFAULT_TRANSLATIONS[langCode];
    return translations[langCode];
  }
  
  try {
    // 显示加载指示器
    showLanguageLoadingIndicator();
    
    console.log(`尝试从服务器加载语言文件: ${langCode}`);
    
    // 尝试从服务器加载语言文件
    const response = await fetch(`/static/i18n/${langCode}.json`);
    
    if (response.ok) {
      const data = await response.json();
      console.log(`成功从服务器加载语言: ${langCode}`);
      translations[langCode] = data;
      return data;
    }
    
    console.warn(`无法加载语言: ${langCode}，尝试基础语言`);
    
    // 尝试基础语言 (例如 zh-CN -> zh)
    const baseLang = langCode.split('-')[0];
    if (baseLang !== langCode) {
      if (translations[baseLang]) {
        console.log(`使用已加载的基础语言: ${baseLang}`);
        return translations[baseLang];
      }
      
      if (DEFAULT_TRANSLATIONS[baseLang]) {
        console.log(`使用内置的基础语言包: ${baseLang}`);
        translations[baseLang] = DEFAULT_TRANSLATIONS[baseLang];
        return translations[baseLang];
      }
      
      // 尝试从服务器加载基础语言
      const baseResponse = await fetch(`/static/i18n/${baseLang}.json`);
      if (baseResponse.ok) {
        const baseData = await baseResponse.json();
        console.log(`成功从服务器加载基础语言: ${baseLang}`);
        translations[baseLang] = baseData;
        return baseData;
      }
    }
    
    // 所有尝试都失败，回退到英语
    console.warn(`无法加载语言 ${langCode} 或基础语言 ${baseLang}，回退到英语`);
    if (!translations['en']) {
      translations['en'] = DEFAULT_TRANSLATIONS['en'];
    }
    return translations['en'];
  } catch (error) {
    console.error(`加载语言失败: ${langCode}`, error);
    
    // 出错时回退到英语
    if (!translations['en']) {
      translations['en'] = DEFAULT_TRANSLATIONS['en'];
    }
    return translations['en'];
  } finally {
    hideLanguageLoadingIndicator();
  }
}

// 显示语言加载指示器
function showLanguageLoadingIndicator() {
  const existingIndicator = document.getElementById('language-loading-indicator');
  if (existingIndicator) return;
  
  const indicator = document.createElement('div');
  indicator.id = 'language-loading-indicator';
  
  // 使用翻译文本，如果当前语言未定义或未加载，则使用英语
  let loadingText = 'Loading language...';
  if (translations[currentLang] && translations[currentLang].loadingLanguage) {
    loadingText = translations[currentLang].loadingLanguage;
  } else if (translations['en'] && translations['en'].loadingLanguage) {
    loadingText = translations['en'].loadingLanguage;
  }
  
  indicator.textContent = loadingText;
  indicator.style.position = 'fixed';
  indicator.style.top = '10px';
  indicator.style.right = '10px';
  indicator.style.background = 'rgba(0,0,0,0.7)';
  indicator.style.color = 'white';
  indicator.style.padding = '5px 10px';
  indicator.style.borderRadius = '3px';
  indicator.style.zIndex = '9999';
  document.body.appendChild(indicator);
}

// 隐藏语言加载指示器
function hideLanguageLoadingIndicator() {
  const indicator = document.getElementById('language-loading-indicator');
  if (indicator) {
    indicator.remove();
  }
}

/**
 * 获取翻译文本
 * @param {string} key - 翻译键名
 * @param {Object} variables - 用于替换文本中的变量
 * @returns {string} 翻译后的文本
 */
function translate(key, variables = {}) {
  // 安全检查 - 确保当前语言和翻译对象存在
  if (!currentLang || !translations || !translations[currentLang]) {
    console.warn(`翻译失败：当前语言[${currentLang}]或翻译对象不存在，尝试使用英文回退`);
    if (translations && translations['en']) {
      // 使用英文作为回退
      const enText = translations['en'][key];
      if (enText) return enText;
    }
    console.warn(`翻译失败：未找到键 [${key}] 的翻译，返回键名`);
    return key; // 如果英文也没有，返回键名
  }
  
  // 获取当前语言的翻译
  let text = translations[currentLang][key];
  
  // 如果当前语言没有该翻译，尝试使用英语
  if (!text && currentLang !== 'en' && translations['en']) {
    console.warn(`当前语言[${currentLang}]未找到键[${key}]的翻译，尝试使用英文翻译`);
    text = translations['en'][key];
  }
  
  // 如果仍然没有找到，返回键名
  if (!text) {
    console.warn(`翻译失败：未找到键 [${key}] 的翻译，返回键名`);
    return key;
  }
  
  // 添加重复次数变量（如果未提供）
  if (!variables.hasOwnProperty('repetitions')) {
    variables.repetitions = getRepetitions();
  }
  
  // 处理变量插值
  if (typeof text === 'string') {
    return text.replace(/\{(\w+)\}/g, (_, name) => {
      return variables[name] !== undefined ? variables[name] : `{${name}}`;
    });
  }
  
  return text;
}

// 获取当前速度的翻译文本
function getSpeedText(speedValue) {
  if (!speedValue) return translations[currentLang].normalSpeed;
  
  // 标准化速度值 - 将所有语言的速度值映射到标准值
  const normalSpeedTerms = ['正常', 'normal', 'normale', 'normál', 'normaal', 'सामान्य', 'عادي', 'normale', 'normal', '通常'];
  const fastSpeedTerms = ['快速', 'fast', 'schnell', 'rapide', 'rápida', 'rápido', 'veloce', 'तेज़', 'سريع', '快', '速い'];
  const slowSpeedTerms = ['慢速', 'slow', 'langsam', 'lente', 'lenta', 'lento', 'धीमा', 'بطيء', '慢', '遅い'];
  
  let standardSpeed = 'normal'; // 默认值
  
  // 直接检查当前语言的速度术语
  if (currentLang === 'fr') {
    if (speedValue === 'normale') standardSpeed = 'normal';
    else if (speedValue === 'rapide') standardSpeed = 'fast';
    else if (speedValue === 'lente') standardSpeed = 'slow';
  } else if (currentLang === 'de') {
    if (speedValue === 'normal') standardSpeed = 'normal';
    else if (speedValue === 'schnell') standardSpeed = 'fast';
    else if (speedValue === 'langsam') standardSpeed = 'slow';
  } else if (currentLang === 'es') {
    if (speedValue === 'normal') standardSpeed = 'normal';
    else if (speedValue === 'rápida') standardSpeed = 'fast';
    else if (speedValue === 'lenta') standardSpeed = 'slow';
  } else if (normalSpeedTerms.includes(speedValue)) {
    standardSpeed = 'normal';
  } else if (fastSpeedTerms.includes(speedValue)) {
    standardSpeed = 'fast';
  } else if (slowSpeedTerms.includes(speedValue)) {
    standardSpeed = 'slow';
  }
  
  // 根据当前语言返回对应的翻译
  return translations[currentLang][standardSpeed + 'Speed'] || speedValue;
}

// 格式化日期
function formatDate(date, options = {}) {
  return new Intl.DateTimeFormat(currentLang, options).format(date);
}

// 格式化数字
function formatNumber(number, options = {}) {
  return new Intl.NumberFormat(currentLang, options).format(number);
}

/**
 * 切换应用的当前语言
 * @param {string} langCode - 语言代码，如'zh', 'en', 'ja'等
 * @returns {Promise<boolean>} 是否成功切换语言
 */
async function switchLanguage(langCode) {
  console.log('切换语言到:', langCode);
  
  // 如果语言代码无效，使用默认语言
  if (!langCode || !SUPPORTED_LANGUAGES[langCode]) {
    console.warn(`无效的语言代码: ${langCode}，使用默认语言 zh`);
    langCode = 'zh';
  }
  
  // 显示加载指示器
  showLanguageLoadingIndicator();
  
  try {
    // 保存当前速度值（如果存在）
    const speedIndicator = document.getElementById('speed-indicator');
    const currentSpeedValue = speedIndicator ? speedIndicator.textContent : null;
    
    // 加载语言文件
    if (!translations[langCode]) {
      translations[langCode] = await loadLanguage(langCode);
    }
    
    // 更新当前语言
    currentLang = langCode;
    
    // 应用RTL/LTR方向
    applyLanguageDirection(langCode);
    
    // 应用翻译
    applyTranslations();
    
    // 更新速度指示器（如果存在）
    if (speedIndicator && currentSpeedValue) {
      // 使用getSpeedText函数获取新语言下的速度文本
      const newSpeedText = getSpeedText(currentSpeedValue);
      speedIndicator.textContent = newSpeedText;
      
      // 更新提示文本
      updatePromptWithSpeed(newSpeedText);
    }
    
    // 更新所有可能包含文本的元素
    updateAllTextElements();
    
    // 保存用户偏好
    localStorage.setItem('preferredLanguage', langCode);
    
    // 更新语言选择器UI
    const selector = document.getElementById('language-selector');
    if (selector) selector.value = langCode;
    
    // 触发语言变更事件
    document.dispatchEvent(new CustomEvent('languageChanged', { detail: { language: langCode } }));
    
    return true;
  } catch (error) {
    console.error(`切换语言到 ${langCode} 时出错:`, error);
    currentLang = 'zh'; // 回退到中文
    return false;
  } finally {
    hideLanguageLoadingIndicator();
  }
}

// 更新页面中所有可能包含文本的元素
function updateAllTextElements() {
  // 获取所有带data-i18n属性的元素
  const elements = document.querySelectorAll('[data-i18n]');
  
  // 遍历并更新每个元素
  elements.forEach(element => {
    const key = element.getAttribute('data-i18n');
    
    // 特殊处理promptTemplate
    if (key === 'promptTemplate') {
      updatePromptTemplate(element);
    } else {
      // 常规翻译处理
      const translatedText = translate(key);
      if (translatedText) {
        element.innerHTML = translatedText;
      }
    }
    
    // 更新标题
    if (key === 'documentTitle') {
      document.title = translate(key);
    }
  });
  
  // 更新lang属性
  document.documentElement.lang = currentLang;
}

// 特殊处理promptTemplate的翻译
function updatePromptTemplate(element) {
  const key = 'promptTemplate';
  const translatedTemplate = translate(key);
  
  if (translatedTemplate) {
    // 创建临时元素解析HTML
    const tempDiv = document.createElement('div');
    tempDiv.innerHTML = translatedTemplate;
    
    // 确保span标签有正确的属性
    const span = tempDiv.querySelector('span');
    if (span) {
      span.id = 'speed-indicator';
      span.className = 'highlight';
    }
    
    // 将处理后的HTML设置回原始元素
    element.innerHTML = tempDiv.innerHTML;
  }
}

// 更新提示文本中的速度
function updatePromptWithSpeed(speedText) {
  const promptSection = document.getElementById('prompt-section');
  if (promptSection) {
    const promptTemplate = translations[currentLang].promptTemplate;
    const promptHtml = promptTemplate.replace('{speed}', speedText);
    promptSection.innerHTML = `<p id="prompt-text">${promptHtml}</p>`;
    
    // 确保速度指示器显示正确的文本
    const newSpeedIndicator = document.getElementById('speed-indicator');
    if (newSpeedIndicator) {
      newSpeedIndicator.textContent = speedText;
    }
  }
}

/**
 * 将翻译应用到页面上
 */
function applyTranslations() {
    try {
        // 更新所有带有data-i18n属性的元素
        updateAllTextElements();
        
        // 给网页添加语言类，用于CSS样式
        document.documentElement.classList.forEach(cls => {
            if (cls.startsWith('lang-')) {
                document.documentElement.classList.remove(cls);
            }
        });
        document.documentElement.classList.add(`lang-${currentLang}`);
        
        // 更新HTML的lang属性
        document.documentElement.lang = currentLang;
        
        // 设置初始化完成标志
        isInitialized = true;
        console.log('语言应用完成:', currentLang);
    } catch (error) {
        console.error('应用翻译时出错:', error);
    }
}

/**
 * 更新按钮文本
 * 根据按钮的状态（录音中、暂停、初始）设置相应的文本
 */
function updateButtonTexts() {
  const prevBtn = document.getElementById('prev-btn');
  const recordBtn = document.getElementById('record-btn');
  const nextBtn = document.getElementById('next-btn');
  const submitBtn = document.getElementById('submit-btn');
  
  if (prevBtn) prevBtn.textContent = translate('prevBtn');
  
  // 根据录音状态设置录音按钮文本
  if (recordBtn) {
    if (recordBtn.classList.contains('recording')) {
      // 录音中状态
      recordBtn.textContent = translate('pause');
    } else if (recordBtn.dataset.state === 'paused') {
      // 暂停状态 - 使用data-state属性而不是检查文本
      recordBtn.textContent = translate('resume');
    } else {
      // 初始状态
      recordBtn.textContent = translate('recordBtn');
    }
  }
  
  // 根据是否是最后一个单词设置下一词按钮文本
  if (nextBtn) {
    if (nextBtn.dataset.state === 'complete' || 
        nextBtn.textContent === translate('complete')) {
      nextBtn.textContent = translate('complete');
      // 设置data-state属性标记完成状态
      nextBtn.dataset.state = 'complete';
    } else {
      nextBtn.textContent = translate('nextBtn');
      // 移除状态标记
      delete nextBtn.dataset.state;
    }
  }
  
  // 更新提交按钮
  if (submitBtn) {
    submitBtn.textContent = translate('submit');
  }
}

// 更新提示文本
function updateHintTexts() {
  const hintSection = document.querySelector('.hint-section');
  if (hintSection) {
    const hints = hintSection.querySelectorAll('p');
    
    // 使用data-i18n属性更新所有提示文本
    hints.forEach(hint => {
      const key = hint.getAttribute('data-i18n');
      if (key) {
        if (key === 'hint1') {
          // 对于hint1，使用innerHTML并传递repetitions变量
          hint.innerHTML = translate(key, { repetitions: getRepetitions() });
        } else {
          // 对于其他提示，只需使用textContent
          hint.textContent = translate(key);
        }
      }
    });
  }
}

// 应用语言方向
function applyLanguageDirection(langCode) {
  const direction = SUPPORTED_LANGUAGES[langCode]?.direction || 'ltr';
  document.documentElement.dir = direction;
  document.documentElement.setAttribute('lang', langCode);
  
  // 添加方向特定的类，用于CSS样式调整
  if (direction === 'rtl') {
    document.body.classList.add('rtl-layout');
    document.body.classList.remove('ltr-layout');
  } else {
    document.body.classList.add('ltr-layout');
    document.body.classList.remove('rtl-layout');
  }
}

// 创建语言选择器UI
function createLanguageSelector(container) {
  if (!container) {
    // 如果没有提供容器，创建一个
    container = document.createElement('div');
    container.id = 'language-selector-container';
    container.style.position = 'fixed';
    container.style.top = '10px';
    container.style.right = '10px';
    container.style.zIndex = '1000';
    document.body.appendChild(container);
  }
  
  // 清空容器
  container.innerHTML = '';
  
  // 创建选择器
  const select = document.createElement('select');
  select.id = 'language-selector';
  
  // 设置选择器样式
  select.style.padding = '8px 30px 8px 10px';
  select.style.borderRadius = '5px';
  select.style.border = '1px solid #ddd';
  select.style.backgroundColor = '#fff';
  select.style.boxShadow = '0 2px 5px rgba(0,0,0,0.1)';
  select.style.fontSize = '14px';
  select.style.fontWeight = '500';
  select.style.cursor = 'pointer';
  select.style.appearance = 'none';
  select.style.backgroundImage = 'url("data:image/svg+xml;charset=US-ASCII,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%22292.4%22%20height%3D%22292.4%22%3E%3Cpath%20fill%3D%22%23131313%22%20d%3D%22M287%2069.4a17.6%2017.6%200%200%200-13-5.4H18.4c-5%200-9.3%201.8-12.9%205.4A17.6%2017.6%200%200%200%200%2082.2c0%205%201.8%209.3%205.4%2012.9l128%20127.9c3.6%203.6%207.8%205.4%2012.8%205.4s9.2-1.8%2012.8-5.4L287%2095c3.5-3.5%205.4-7.8%205.4-12.8%200-5-1.9-9.2-5.5-12.8z%22%2F%3E%3C%2Fsvg%3E")';
  select.style.backgroundRepeat = 'no-repeat';
  select.style.backgroundPosition = 'right 10px top 50%';
  select.style.backgroundSize = '10px auto';
  
  // 添加语言选项
  Object.entries(SUPPORTED_LANGUAGES).forEach(([code, info]) => {
    const option = document.createElement('option');
    option.value = code;
    option.textContent = info.nativeName;
    
    select.appendChild(option);
  });
  
  // 设置当前语言
  select.value = currentLang;
  
  // 添加事件监听器
  select.addEventListener('change', (e) => {
    const newLang = e.target.value;
    // 切换语言
    switchLanguage(newLang);
  });
  
  // 添加到容器
  container.appendChild(select);
  
  return select;
}

/**
 * 初始化语言
 * 检测用户语言并加载相应的翻译
 */
async function initLanguage() {
    try {
        // 显示加载指示器（如果存在）
        showLoadingIndicator();
        
        // 1. 检查本地存储中是否有保存的语言设置
        const savedLang = localStorage.getItem('preferredLanguage');
        let detectedLang = null;
        
        // 如果有保存的语言设置并且是支持的语言，使用保存的语言
        if (savedLang && SUPPORTED_LANGUAGES[savedLang]) {
            console.log('使用保存的语言设置:', savedLang);
            detectedLang = savedLang;
        } else {
            // 2. 如果没有保存的语言设置，检测用户语言
            console.log('尝试检测用户语言...');
            detectedLang = await detectUserLanguage();
            
            // 保存检测到的语言设置到本地存储
            localStorage.setItem('preferredLanguage', detectedLang);
        }
        
        // 3. 加载检测到的语言的翻译
        await loadLanguage(detectedLang);
        
        // 设置当前语言
        currentLang = detectedLang;
        
        // 4. 将语言应用到页面
        applyTranslations();
        
        // 隐藏加载指示器
        hideLoadingIndicator();
        
        // 返回检测到的语言
        return detectedLang;
    } catch (error) {
        console.error('初始化语言失败:', error);
        
        // 出错时隐藏加载指示器
        hideLoadingIndicator();
        
        // 出错时加载默认语言
        try {
            await loadLanguage('en');
            currentLang = 'en';
            applyTranslations();
            return 'en';
        } catch (err) {
            console.error('加载默认语言失败:', err);
            return 'en'; // 即使加载失败也返回默认语言代码
        }
    }
}

// 检查未翻译的内容
function checkForUntranslatedContent() {
  // 检查关键UI元素
  const promptTexts = document.querySelectorAll('.prompt-section p');
  const hintTexts = document.querySelectorAll('.hint-section p');
  const buttons = document.querySelectorAll('button');
  
  let hasEnglish = false;
  let hasChinese = false;
  
  // 简单检测文本是否包含英文或中文
  function checkTextLanguage(text) {
    if (/[a-zA-Z]/.test(text)) hasEnglish = true;
    if (/[\u4e00-\u9fa5]/.test(text)) hasChinese = true;
  }
  
  // 检查提示文本
  promptTexts.forEach(el => checkTextLanguage(el.textContent));
  // 检查提示区域
  hintTexts.forEach(el => checkTextLanguage(el.textContent));
  // 检查按钮
  buttons.forEach(el => checkTextLanguage(el.textContent));
  
  // 如果发现混合语言
  if (hasEnglish && hasChinese) {
    console.warn('检测到界面中存在中英文混合');
    
    // 强制重新应用当前语言
    if (currentLang === 'zh') {
      console.log('强制重新应用中文');
      switchLanguage('zh');
    } else if (currentLang === 'en') {
      console.log('强制重新应用英文');
      switchLanguage('en');
    }
  }
}

// 导出函数和变量
window.i18n = {
  initLanguage,
  switchLanguage,
  getCurrentLang: () => currentLang,
  getSpeedText,
  translate,
  formatDate,
  formatNumber,
  getSupportedLanguages: () => SUPPORTED_LANGUAGES,
  createLanguageSelector,
  get isInitialized() { return isInitialized; }
};

/**
 * 显示加载指示器
 */
function showLoadingIndicator() {
    try {
        const loadingIndicator = document.getElementById('i18n-loading');
        if (loadingIndicator) {
            loadingIndicator.style.display = 'block';
        } else if (window.showLoadingIndicator && typeof window.showLoadingIndicator === 'function') {
            // 如果存在全局加载指示器函数，调用它
            window.showLoadingIndicator();
        }
    } catch (error) {
        console.error('显示加载指示器失败:', error);
    }
}

/**
 * 隐藏加载指示器
 */
function hideLoadingIndicator() {
    try {
        const loadingIndicator = document.getElementById('i18n-loading');
        if (loadingIndicator) {
            loadingIndicator.style.display = 'none';
        } else if (window.hideLoadingIndicator && typeof window.hideLoadingIndicator === 'function') {
            // 如果存在全局加载指示器函数，调用它
            window.hideLoadingIndicator();
        }
    } catch (error) {
        console.error('隐藏加载指示器失败:', error);
    }
} 
